home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / hips / sources / tools / mixmul.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-06  |  14.8 KB  |  645 lines
  1. /*
  2. % mulmix.c - multiply each frame in a sequence by the corresponding frame
  3. %    of another sequence pixel by pixel. If the file which has higher
  4. %    hirechy consists of less frames, then that last frame is multiplied by each
  5. %    later frames in the input sequence, otherwise corresponding frames are
  6. %    used.  The following combinations of image formats are supported:
  7. %
  8. %        File sequence        Standard input sequence
  9. %
  10. %        any non pyramid format combinations
  11. %        integer pyramid        integer pyramid
  12. %        float pyramid        float pyramid
  13. %
  14. %    Copyright (c)    1990    Jin, Guojun
  15. %
  16. % usage:    mulmix filter_file < image > output
  17. %
  18. % AUTHOR    Guojun Jin - Lawrence Berkeley Laboratory    12/15/90
  19. %
  20. % last change:    Date 6/2/91 - adding VFFT format.
  21. */
  22.  
  23. #include "header.def"
  24. #include "imagedef.h"
  25.  
  26. U_IMAGE    *img, *img1;
  27.  
  28. #define    ibuf    img1->dest
  29. #define    obuf    img->dest
  30. #define    itemp1    img1->src /* lower level filter frame to higher level transfer */
  31. #define    otemp    img->src /* image BYTE or SHORT to INTEGER transfer buffer */
  32. #define    in_fp0    img->IN_FP
  33. #define    out_fp0    img->OUT_FP
  34. #define    in_fp1    img1->IN_FP
  35.  
  36. MType    fsize, diffsize, dimen1len, vfsize;
  37. int    ccf=0,    /* both file are complex */
  38.     cf=0;    /* major file is complex */
  39.  
  40. main (argc, argv)
  41. int    argc;
  42. char**    argv;
  43. {
  44. int    toplev, i;
  45.  
  46. img = (U_IMAGE*)zalloc(sizeof(*img), 1),    /* img has higher hirechy than img1 */
  47. img1 = (U_IMAGE*)zalloc(sizeof(*img1), 1);
  48.  
  49. format_init(img, IMAGE_INIT_TYPE, HIPS, -1, *argv, "S16-1");
  50. format_init(img1, IMAGE_INIT_TYPE, HIPS, -1, *argv, "S16-1");
  51.  
  52. if (argv[argc-1][0]=='-' && argv[argc-1][1]=='D') argc--;
  53. if (argc<2)
  54.     syserr("file argument missing\n%s filter_file < image > output", *argv);
  55. if ((in_fp1=fopen(argv[1], "rb")) == NULL)
  56.     syserr("can't open frame file - %s", argv[1]);
  57.  
  58. (*img->header_handle)(HEADER_READ, img, 0, 0);
  59. (*img1->header_handle)(HEADER_FREAD, img1, in_fp1, 0);
  60. img->o_form = img->in_form;
  61. img1->o_form = img1->in_form;
  62.  
  63.     if (img->in_form < img1->in_form) {
  64.     register U_IMAGE*    itemp = img;    img = img1;    img1 = itemp;
  65.     }
  66.     diffsize = img->pxl_in - img1->pxl_in;
  67.     if (diffsize)
  68.         if (img->in_form == IFMT_COMPLEX ||
  69.             img->in_form == IFMT_VFFT2D ||
  70.             img->in_form == IFMT_VFFT3D)
  71.             diffsize -= 4;
  72.         else if (img->in_form == IFMT_DBLCOM ||
  73.             img->in_form == IFMT_DVFFT2D ||
  74.             img->in_form == IFMT_DVFFT3D)
  75.             diffsize -= 12;
  76.     if (img->in_form <= IFMT_SHORT)
  77.     {
  78.         if (!img->in_form)
  79.             diffsize = 8;    /* byte to byte    */
  80.         else if(!diffsize)
  81.             diffsize = 10;    /* short to short    */
  82.                 /* otherwise is sht to byte diffsize=1    */
  83.         img->o_form = IFMT_LONG;
  84.         img->pxl_out = sizeof(long);
  85.     }
  86.     else if    ((img->in_form==IFMT_FLOAT || img->in_form==IFMT_COMPLEX) &&
  87.         img1->in_form == IFMT_LONG)
  88.         diffsize = 12;
  89.  
  90.     if (img->height != img1->height || img->width != img1->width)
  91.         syserr("frame file and input header mismatch");
  92.  
  93.     if (!img->pxl_out)
  94.         img->pxl_out = img->pxl_in;
  95.     (*img->header_handle)(HEADER_WRITE, img, argc, argv, True);
  96.  
  97.     if (img->in_form == IFMT_LONGPYR || img->in_form == IFMT_FLOATPYR)
  98.        if    (img->in_form != img1->in_form)
  99.         syserr("format not matching");
  100.        else{
  101.         if (upread(&toplev, 1, sizeof(toplev), in_fp0) != sizeof(toplev))
  102.             syserr("error reading standard input number of levels");
  103.         if (upread(&i, 1, sizeof(i), in_fp1) != sizeof(i))
  104.             syserr("error reading file input number of levels");
  105.         if (toplev != i)
  106.             prgmerr(i, "pyramid number of levels mismatch");
  107.         fsize = pyrnumpix(toplev,img->height,img->width);
  108.         if (fwrite(&toplev,1,sizeof(toplev),out_fp0) != sizeof(toplev))
  109.             syserr("error writing number of pyramid levels");
  110.        }
  111.     else    fsize = img->height*img->width;
  112.     dimen1len = (img->width>>1) + 1;
  113.     vfsize = img->height * dimen1len;
  114.     if (img->in_form == IFMT_COMPLEX || img->in_form == IFMT_DBLCOM ||
  115.         img->in_form >= IFMT_VFFT3D && img->in_form < IFMT_VVFFT3D){
  116.         cf++;
  117.         if (img->in_form==img1->in_form)    ccf++;
  118.     }
  119.  
  120. ibuf = nzalloc(fsize, img->pxl_out, "mul_ibuf");
  121. obuf = nzalloc(fsize, img->pxl_out, "mul_obuf");
  122. if (diffsize && diffsize < 12)
  123.     itemp1 = zalloc(fsize, img1->pxl_in);
  124. else    itemp1 = ibuf;
  125.  
  126. if (diffsize == 1 || diffsize == 8 || diffsize == 10)    {
  127.     otemp = zalloc(fsize, img->pxl_in);
  128.     mulbs(img->frames, img1->frames);
  129. }
  130. else{
  131. /*    ibuf = zalloc(fsize, img1->pxl_in + (diffsize&7));    */
  132.     otemp = obuf;
  133.     switch(img->in_form){
  134.     case IFMT_LONG:
  135.     case IFMT_LONGPYR:
  136.         mulint(img->frames, img1->frames);
  137.         break;
  138.     case IFMT_FLOAT:
  139.     case IFMT_COMPLEX:
  140.     case IFMT_FLOATPYR:
  141.         mulfloat(img->frames,img1->frames);
  142.         break;
  143.     case IFMT_VFFT2D:
  144.     case IFMT_VFFT3D:
  145.         mulvfft(img->frames,img1->frames, img);
  146.         break;
  147.     case IFMT_DVFFT2D:
  148.     case IFMT_DVFFT3D:
  149.         muldvfft(img->frames,img1->frames, img);
  150.         break;
  151.     default:
  152.         muldbl(img->frames,img1->frames);
  153.     }
  154. }
  155. exit(0);
  156. }
  157.  
  158. mulbs(num_frame,fnum_frame)
  159. {
  160. register int    i,*obp,*ibp;
  161. int    f;
  162.  
  163.     for (f=0;f<num_frame;f++){
  164.         if (fnum_frame) {    /* read base (mask) frame(s)    */
  165.         fnum_frame--;
  166.         if ((i=(*img1->std_swif)(FI_LOAD_FILE, img1, 0, No)) != fsize)
  167.             syserr("reading error during bstoi transfer1 %d", i);
  168.         switch(diffsize)
  169.         {
  170.         case 8:
  171.         case 1:    btoi(itemp1, ibuf, fsize);    break;
  172.         case 10:stoi(itemp1, ibuf, fsize);    break;
  173.         default:    syserr("BS1 to int error %d", diffsize);
  174.         }
  175.         }
  176.         if ((i=(*img->std_swif)(FI_LOAD_FILE, img, 0, No)) != fsize)
  177.         syserr("reading error during bstoi transfer %d", i);
  178.         switch(diffsize)
  179.         {
  180.         case 8:    btoi(otemp, obuf, fsize);    break;
  181.         case 1:
  182.         case 10:stoi(otemp, obuf, fsize);    break;
  183.         default:    syserr("BS0 to int error %d", diffsize);
  184.         }
  185.  
  186.         obp = (int*)obuf;
  187.         ibp = (int*)ibuf;
  188.         for (i=fsize; i--;)
  189.         *obp++ *= *ibp++;
  190.         if (fwrite(obuf, img->pxl_out, fsize, out_fp0) != fsize)
  191.             syserr("error during mulbs write int");
  192.     }
  193. }
  194.  
  195. mulint(num_frame,fnum_frame)
  196. {
  197. register int    i,*obp,*ibp;
  198. int    f;
  199.  
  200.     for (f=0;f<num_frame;f++) {
  201.         if (fnum_frame) {
  202.         fnum_frame--;
  203.         if ((i=(*img1->std_swif)(FI_LOAD_FILE, img1, 0, No)) != fsize)
  204.             syserr("reading error during btoi transfer %d", i);
  205.         switch(diffsize)
  206.         {
  207.         case 0:    if (debug) mesg("int x int\n");    break;
  208.         case 2:    stoi(itemp1, ibuf, fsize);    break;
  209.         case 3: btoi(itemp1, ibuf, fsize);    break;
  210.         default:prgmerr(diffsize, "X to int error %d", diffsize);
  211.         }
  212.         }
  213.         if ((*img->std_swif)(FI_LOAD_FILE, img, 0, No) != fsize)
  214.         syserr("error during last int sequence read");
  215.         obp = (int*)obuf;
  216.         ibp = (int*)ibuf;
  217.         for (i=fsize; i--;)
  218.         *obp++ *= *ibp++;
  219.         if (fwrite(obuf,img->pxl_out,fsize,out_fp0) != fsize)
  220.         syserr("error during write");
  221.     }
  222. }
  223.  
  224. mulfloat(num_frame,fnum_frame)
  225. {
  226. int    f;
  227. register int    i;
  228. register float    *obp,*ibp;
  229. float    R,I;
  230.  
  231.     for (f=0;f<num_frame;f++) {
  232.         if (fnum_frame) {
  233.         fnum_frame--;
  234.         if ((i=(*img1->std_swif)(FI_LOAD_FILE, img1, 0, No)) != fsize)
  235.             syserr("reading error during xtof transfer %d", i);
  236.         else    message("read %d bytes\n", i);
  237.         switch(diffsize)
  238.         {
  239.         case 12:itof(itemp1, ibuf, fsize);    break;
  240.         case 3:    btof(itemp1, ibuf, fsize);    break;
  241.         case 2:    stof(itemp1, ibuf, fsize);    break;
  242.         case 0:    if (debug) mesg("fp x fp\n");    break;
  243.         default:syserr("X to float error %d", diffsize);
  244.         }
  245.         }
  246.         if ((*img->std_swif)(FI_LOAD_FILE, img, 0, No) != fsize)
  247.             syserr("error during last float sequence read");
  248.         obp = (float*)obuf;
  249.         ibp = (float*)ibuf;
  250.         for (i=fsize; i--;) {
  251.         if(ccf) {
  252.             R = (*ibp)*(*obp) - (*(ibp+1))*(*(obp+1));
  253.             I = (*ibp)*(*(obp+1)) + (*obp)*(*(ibp+1));
  254.             *obp++ = R; *obp++ = I; ibp += 2;
  255.         }
  256.         else {    if (cf)    *obp++ *= *ibp;
  257.             *obp++ *= *ibp++;
  258.         }
  259.         }
  260.         if (fwrite(obuf, img->pxl_out, fsize, out_fp0) != fsize)
  261.             syserr("error during write");
  262.     }
  263. }
  264.  
  265. muldbl(num_frame,fnum_frame)
  266. {
  267. register int    i;
  268. int    f,s1=1<<ccf, s0=1<<cf;
  269. register double    *obp, *ibp;
  270. double    R,I;
  271.  
  272.     for (f=0;f<num_frame;f++) {
  273.         if (fnum_frame) {
  274.         fnum_frame--;
  275.         if (diffsize)
  276.         {
  277.         if((i=upread(itemp1, (sizeof(double)-(diffsize&7)), fsize, in_fp1))
  278.             != fsize)
  279.             syserr("reading error during transfer");
  280.         else    message("read %d bytes\n", i);
  281.         switch(diffsize)
  282.             {
  283.             case 4:    ftod(itemp1, ibuf, fsize);    break;
  284.             case 12:itod(itemp1, ibuf, fsize);    break;
  285.             case 6:    stod(itemp1, ibuf, fsize);    break;
  286.             case 7:    btod(itemp1, ibuf, fsize);    break;
  287.             default:syserr("X to double error %d", diffsize);
  288.             }
  289.         }
  290.         else if (upread(ibuf, s1 * sizeof(double), fsize, in_fp1) !=
  291.             fsize)
  292.                 syserr("error during read");
  293.         }
  294.         if (upread(obuf, s0 * sizeof(double), fsize, in_fp0) != fsize)
  295.             syserr("error during fixed sequence read");
  296.         obp = (double*)obuf;
  297.         ibp = (double*)ibuf;
  298.         for (i=fsize;i--;) {
  299.         if(ccf) {
  300.             R = (*ibp)*(*obp) - (*(ibp+1))*(*(obp+1));
  301.             I = (*ibp)*(*(obp+1)) + (*obp)*(*(ibp+1));
  302.             *obp++ = R; *obp++ = I; ibp += 2;
  303.         }
  304.         else {    if (cf)    *obp++ *= *ibp;
  305.             *obp++ *= *ibp++;
  306.         }
  307.         }
  308.         if (fwrite(obuf,s0*sizeof(double),fsize,out_fp0) != fsize)
  309.             syserr("error during write");
  310.     }
  311. }
  312.  
  313. mulvfft(num_frame,fnum_frame, img)
  314. U_IMAGE    *img;
  315. {
  316. int    f, s1=1<<ccf,    /* filter file size */
  317.     s0=1<<cf;    /* major file size */
  318. register int    i;
  319. register float    *obp,*ibp;
  320. float    R,I;
  321.  
  322.     for (f=0;f<num_frame;f++) {
  323.         if (fnum_frame) {
  324.         fnum_frame--;
  325.         if (diffsize)
  326.         {
  327.             if((i=upread(itemp1, (sizeof(float)-diffsize%4), fsize, in_fp1))
  328.             != fsize)
  329.             syserr("reading error during xtof transfer %d", i);
  330.             else    message("read %d bytes\n", i);
  331.             switch(diffsize)
  332.             {
  333.             case 12:itov(itemp1, ibuf, img);    break;
  334.             case 3:    btov(itemp1, ibuf, img);    break;
  335.             case 2:    stov(itemp1, ibuf, img);    break;
  336.             default:syserr("X to float error %d", diffsize);
  337.             }
  338.         }
  339.         else if (s1==1){
  340.             if ((i=upread(ibuf, sizeof(float), fsize, in_fp1)) !=
  341.             fsize)
  342.                 syserr("error during vfft read");
  343.             else    ftov(ibuf, img);
  344.             }
  345.             else
  346.             if ((i=upread(ibuf, sizeof(float)<<1, vfsize, in_fp1)) !=
  347.             vfsize)
  348.                 syserr("error during vfft read");
  349.  
  350.         }
  351.         if (upread(obuf, s0 * sizeof(float), vfsize, in_fp0) != vfsize)
  352.             syserr("error during last vfft sequence read");
  353.         obp = (float*)obuf;
  354.         ibp = (float*)ibuf;
  355.         for (i=vfsize; i--;){
  356.         if (ccf){
  357.             R = (*ibp)*(*obp) - (*(ibp+1))*(*(obp+1));
  358.             I = (*ibp)*(*(obp+1)) + (*obp)*(*(ibp+1));
  359.             *obp++ = R; *obp++ = I; ibp += 2;
  360.         }
  361.         else {    if (cf)    *obp++ *= *ibp;
  362.             *obp++ *= *ibp++;
  363.         }
  364.         }
  365.         if (fwrite(obuf, s0 * sizeof(float), vfsize, out_fp0) != vfsize)
  366.             syserr("error during v_write");
  367.     }
  368. }
  369.  
  370. muldvfft(num_frame,fnum_frame, img)
  371. U_IMAGE    *img;
  372. {
  373. register int    i;
  374. int    f,s1=1<<ccf, s0=1<<cf;
  375. register double    *obp, *ibp;
  376. double    R,I;
  377.  
  378.     for (f=0;f<num_frame;f++) {
  379.         if (fnum_frame) {
  380.         fnum_frame--;
  381.         if (diffsize)
  382.         {
  383.         if((i=upread(itemp1,(sizeof(double)-(diffsize&7)),fsize,in_fp1))
  384.             != fsize)
  385.             syserr("reading error during transfer");
  386.         else    message("read %d bytes\n", i);
  387.         switch(diffsize)
  388.             {
  389.             case 4:    ftodv(itemp1, ibuf, img);    break;
  390.             case 12:itodv(itemp1, ibuf, img);    break;
  391.             case 6:    stodv(itemp1, ibuf, img);    break;
  392.             case 7:    btodv(itemp1, ibuf, img);    break;
  393.             default:syserr("X to double error %d", diffsize);
  394.             }
  395.         }
  396.         else if (s1==1){
  397.             if ((i=upread(ibuf, sizeof(double), fsize, in_fp1)) !=
  398.             fsize)
  399.                 syserr("error during dvfft read");
  400.             else    dtodv(ibuf, img);
  401.             }
  402.             else
  403.             if ((i=upread(ibuf, sizeof(double)<<1, vfsize, in_fp1))
  404.                 != vfsize)
  405.                 syserr("error during dvfft read");
  406.  
  407.         }
  408.         if (upread(obuf, s0 * sizeof(double), vfsize, in_fp0) != vfsize)
  409.             syserr("error during fixed dvfft sequence read");
  410.         obp = (double*)obuf;
  411.         ibp = (double*)ibuf;
  412.         for (i=vfsize; i--;) {
  413.         if(ccf) {
  414.             R = (*ibp)*(*obp) - (*(ibp+1))*(*(obp+1));
  415.             I = (*ibp)*(*(obp+1)) + (*obp)*(*(ibp+1));
  416.             *obp++ = R; *obp++ = I; ibp += 2;
  417.         }
  418.         else {    if (cf)    *obp++ *= *ibp;
  419.             *obp++ *= *ibp++;
  420.         }
  421.         }
  422.         if (fwrite(obuf, s0*sizeof(double), vfsize, out_fp0) != vfsize)
  423.             syserr("error during dv_write");
  424.     }
  425. }
  426.  
  427. btoi(ibp, obp, n)
  428. register byte*    ibp;
  429. register int*    obp, n;
  430. {
  431. #ifdef    _DEBUG_
  432. message("%d byte to integer\n", n);
  433. #endif
  434. while (n--)    *obp++ = *ibp++;
  435. }
  436.  
  437. btof(ibp, obp, n)
  438. register byte*    ibp;
  439. register float*    obp;
  440. register int    n;
  441. {
  442. #ifdef    _DEBUG_
  443. message("%d byte to float\n", n);
  444. #endif
  445. while (n--)    *obp++ = (float)*ibp++;
  446. }
  447.  
  448. btod(ibp, obp, n)
  449. register byte*    ibp;
  450. register double    *obp;
  451. register int    n;
  452. {
  453. #ifdef    _DEBUG_
  454. message("%d byte to double\n", n);
  455. #endif
  456. while (n--)    *obp++ = *ibp++;
  457. }
  458.  
  459. stoi(ibp, obp, n)
  460. register unsigned short    *ibp;
  461. register int*    obp, n;
  462. {
  463. #ifdef    _DEBUG_
  464. message("%d short to integer\n", n);
  465. #endif
  466. while (n--)    *obp++ = *ibp++;
  467. }
  468.  
  469. stof(ibp, obp, n)
  470. register unsigned short    *ibp;
  471. register float*    obp;
  472. register int    n;
  473. {
  474. #ifdef    _DEBUG_
  475. message("%d short to float\n", n);
  476. #endif
  477. while (n--)    *obp++ = (float)*ibp++;
  478. }
  479.  
  480. stod(ibp, obp, n)
  481. register unsigned short    *ibp;
  482. register double    *obp;
  483. register int    n;
  484. {
  485. #ifdef    _DEBUG_
  486. message("%d short to double\n", n);
  487. #endif
  488. while (n--)    *obp++ = *ibp++;
  489. }
  490.  
  491. itof(ibp, obp, n)
  492. register int*    ibp, n;
  493. register float*    obp;
  494. {
  495. #ifdef    _DEBUG_
  496. message("%d int to float\n", n);
  497. #endif
  498. while (n--)    *obp++ = *ibp++;
  499. }
  500.  
  501. itod(ibp, obp, n)
  502. register int*    ibp, n;
  503. register double    *obp;
  504. {
  505. #ifdef    _DEBUG_
  506. message("%d int to double\n", n);
  507. #endif
  508. while (n--)    *obp++ = *ibp++;
  509. }
  510.  
  511. ftod(ibp, obp, n)
  512. register float*    ibp;
  513. register double    *obp;
  514. register int    n;
  515. {
  516. #ifdef    _DEBUG_
  517. message("%d float to double\n", n);
  518. #endif
  519. while (n--)    *obp++ = *ibp++;
  520. }
  521.  
  522. btov(ibp, obp, img)
  523. register byte    *ibp;
  524. register float    *obp;
  525. U_IMAGE    *img;
  526. {
  527. register int    c, r;
  528.  
  529. for (r=img->height; r--;){
  530.     for (c=0; c<dimen1len; c++)
  531.     *obp++ = *ibp++;
  532.     ibp += img->width - dimen1len;
  533. }
  534. }
  535.  
  536. stov(ibp, obp, img)
  537. register short    *ibp;
  538. register float    *obp;
  539. U_IMAGE    *img;
  540. {
  541. register int    c, r;
  542.  
  543. for (r=img->height; r--;){
  544.     for (c=0; c<dimen1len; c++)
  545.     *obp++ = *ibp++;
  546.     ibp += img->width - dimen1len;
  547. }
  548. }
  549.  
  550. itov(ibp, obp, img)
  551. register int    *ibp;
  552. register float    *obp;
  553. U_IMAGE    *img;
  554. {
  555. register int    c, r;
  556.  
  557. for (r=img->height; r--;){
  558.     for (c=0; c<dimen1len; c++)
  559.     *obp++ = *ibp++;
  560.     ibp += img->width - dimen1len;
  561. }
  562. }
  563.  
  564. ftov(ibp, obp, img)
  565. register float    *ibp, *obp;
  566. U_IMAGE    *img;
  567. {
  568. register int    c, r;
  569.  
  570. for (r=img->height; r--;){
  571.     for (c=0; c<dimen1len; c++)
  572.     *obp++ = *ibp++;
  573.     ibp += img->width - dimen1len;
  574. }
  575. }
  576.  
  577. btodv(ibp, obp, img)
  578. register byte    *ibp;
  579. register double    *obp;
  580. U_IMAGE    *img;
  581. {
  582. register int    c, r;
  583.  
  584. for (r=img->height; r--;){
  585.     for (c=0; c<dimen1len; c++)
  586.     *obp++ = *ibp++;
  587.     ibp += img->width - dimen1len;
  588. }
  589. }
  590.  
  591. stodv(ibp, obp, img)
  592. register short    *ibp;
  593. register double    *obp;
  594. U_IMAGE    *img;
  595. {
  596. register int    c, r;
  597.  
  598. for (r=img->height; r--;){
  599.     for (c=0; c<dimen1len; c++)
  600.     *obp++ = *ibp++;
  601.     ibp += img->width - dimen1len;
  602. }
  603. }
  604.  
  605. itodv(ibp, obp, img)
  606. register int    *ibp;
  607. register double    *obp;
  608. U_IMAGE    *img;
  609. {
  610. register int    c, r;
  611.  
  612. for (r=img->height; r--;){
  613.     for (c=0; c<dimen1len; c++)
  614.     *obp++ = *ibp++;
  615.     ibp += img->width - dimen1len;
  616. }
  617. }
  618.  
  619. ftodv(ibp, obp, img)
  620. register float    *ibp;
  621. register double    *obp;
  622. U_IMAGE    *img;
  623. {
  624. register int    c, r;
  625.  
  626. for (r=img->height; r--;){
  627.     for (c=0; c<dimen1len; c++)
  628.     *obp++ = *ibp++;
  629.     ibp += img->width - dimen1len;
  630. }
  631. }
  632.  
  633. dtodv(ibp, obp, img)
  634. register double    *ibp, *obp;
  635. U_IMAGE    *img;
  636. {
  637. register int    c, r;
  638.  
  639. for (r=img->height; r--;){
  640.     for (c=0; c<dimen1len; c++)
  641.     *obp++ = *ibp++;
  642.     ibp += img->width - dimen1len;
  643. }
  644. }
  645.